{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling and Simulation in Python\n",
    "\n",
    "Chapter 2\n",
    "\n",
    "Copyright 2017 Allen Downey\n",
    "\n",
    "License: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Configure Jupyter so figures appear in the notebook\n",
    "%matplotlib inline\n",
    "\n",
    "# Configure Jupyter to display the assigned value after an assignment\n",
    "%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n",
    "\n",
    "# import functions from the modsim library\n",
    "from modsim import *\n",
    "\n",
    "# set the random number generator\n",
    "np.random.seed(7)\n",
    "\n",
    "# If this cell runs successfully, it produces no output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modeling a bikeshare system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start with a `State` object that represents the number of bikes at each station.\n",
    "\n",
    "When you display a `State` object, it lists the state variables and their values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare = State(olin=10, wellesley=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the state variables using dot notation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare.olin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare.wellesley"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** What happens if you spell the name of a state variable wrong?  Edit the previous cell, change the spelling of `wellesley`, and run the cell again.\n",
    "\n",
    "The error message uses the word \"attribute\", which is another name for what we are calling a state variable. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Add a third attribute called `babson` with initial value 0, and display the state of `bikeshare` again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Updating\n",
    "\n",
    "We can use the update operators `+=` and `-=` to change state variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "bikeshare.olin -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we display `bikeshare`, we should see the change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         9\n",
       "wellesley    2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, if we subtract a bike from `olin`, we should add it to `wellesley`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         9\n",
       "wellesley    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare.wellesley += 1\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "We can take the code we've written so far and encapsulate it in a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bike_to_wellesley():\n",
    "    bikeshare.olin -= 1\n",
    "    bikeshare.wellesley += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you define a function, it doesn't run the statements inside the function, yet.  When you call the function, it runs the statements inside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         8\n",
       "wellesley    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bike_to_wellesley()\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "One common error is to omit the parentheses, which has the effect of looking up the function, but not calling it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.bike_to_wellesley()>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bike_to_wellesley"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output indicates that `bike_to_wellesley` is a function defined in a \"namespace\" called `__main__`, but you don't have to understand what that means."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Define a function called `bike_to_olin` that moves a bike from Wellesley to Olin.  Call the new function and display `bikeshare`  to confirm that it works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def bike_to_olin():\n",
    "    bikeshare.wellesley -= 1\n",
    "    bikeshare.olin += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         9\n",
       "wellesley    3\n",
       "dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "bike_to_olin()\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`modsim.py` provides `flip`, which takes a probability and returns either `True` or `False`, which are special values defined by Python.\n",
    "\n",
    "The Python function `help` looks up a function and displays its documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function flip in module modsim.modsim:\n",
      "\n",
      "flip(p=0.5)\n",
      "    Flips a coin with the given probability.\n",
      "    \n",
      "    p: float 0-1\n",
      "    \n",
      "    returns: boolean (True or False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(flip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, the probability is 0.7 or 70%.  If you run this cell several times, you should get `True` about 70% of the time and `False` about 30%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flip(0.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following example, we use `flip` as part of an if statement.  If the result from `flip` is `True`, we print `heads`; otherwise we do nothing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "if flip(0.7):\n",
    "    print('heads')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With an else clause, we can print heads or tails depending on whether `flip` returns `True` or `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "heads\n"
     ]
    }
   ],
   "source": [
    "if flip(0.7):\n",
    "    print('heads')\n",
    "else:\n",
    "    print('tails')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step\n",
    "\n",
    "Now let's get back to the bikeshare state.  Again let's start with a new `State` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare = State(olin=10, wellesley=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose that in any given minute, there is a 50% chance that a student picks up a bike at Olin and rides to Wellesley.  We can simulate that like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if flip(0.5):\n",
    "    bike_to_wellesley()\n",
    "    print('Moving a bike to Wellesley')\n",
    "\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And maybe at the same time, there is also a 40% chance that a student at Wellesley rides to Olin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if flip(0.4):\n",
    "    bike_to_olin()\n",
    "    print('Moving a bike to Olin')\n",
    "\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can wrap that code in a function called `step` that simulates one time step.  In any given minute, a student might ride from Olin to Wellesley, from Wellesley to Olin, or both, or neither, depending on the results of `flip`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step():\n",
    "    if flip(0.5):\n",
    "        bike_to_wellesley()\n",
    "        print('Moving a bike to Wellesley')\n",
    "        \n",
    "    if flip(0.4):\n",
    "        bike_to_olin()\n",
    "        print('Moving a bike to Olin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since this function takes no parameters, we call it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "step()\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters\n",
    "\n",
    "As defined in the previous section, `step` is not as useful as it could be, because the probabilities `0.5` and `0.4` are \"hard coded\".\n",
    "\n",
    "It would be better to generalize this function so it takes the probabilities `p1` and `p2` as parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step(p1, p2):\n",
    "    if flip(p1):\n",
    "        bike_to_wellesley()\n",
    "        print('Moving a bike to Wellesley')\n",
    "        \n",
    "    if flip(p2):\n",
    "        bike_to_olin()\n",
    "        print('Moving a bike to Olin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can call it like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moving a bike to Wellesley\n",
      "Moving a bike to Olin\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "step(0.5, 0.4)\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** At the beginning of `step`, add a print statement that displays the values of `p1` and `p2`.  Call it again with values `0.3`, and `0.2`, and confirm that the values of the parameters are what you expect. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3 0.2\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "def step(p1, p2):\n",
    "    print(p1, p2)\n",
    "    if flip(p1):\n",
    "        bike_to_wellesley()\n",
    "        print('Moving a bike to Wellesley')\n",
    "        \n",
    "    if flip(p2):\n",
    "        bike_to_olin()\n",
    "        print('Moving a bike to Olin')\n",
    "        \n",
    "step(0.3, 0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we go on, I'll redefine `step` without the print statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def step(p1, p2):\n",
    "    if flip(p1):\n",
    "        bike_to_wellesley()\n",
    "    \n",
    "    if flip(p2):\n",
    "        bike_to_olin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let's start again with a new `State` object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare = State(olin=10, wellesley=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use a `for` loop to move 4 bikes from Olin to Wellesley."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         6\n",
       "wellesley    6\n",
       "dtype: int64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    bike_to_wellesley()\n",
    "    \n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can simulate 4 random time steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         5\n",
       "wellesley    7\n",
       "dtype: int64"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    step(0.3, 0.2)\n",
    "    \n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If each step corresponds to a minute, we can simulate an entire hour like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         4\n",
       "wellesley    8\n",
       "dtype: int64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(60):\n",
    "    step(0.3, 0.2)\n",
    "\n",
    "bikeshare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After 60 minutes, you might see that the number of bike at Olin is negative.  We'll fix that problem in the next notebook.\n",
    "\n",
    "But first, we want to plot the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TimeSeries\n",
    "\n",
    "`modsim.py` provides an object called a `TimeSeries` that can contain a sequence of values changing over time.\n",
    "\n",
    "We can create a new, empty `TimeSeries` like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Series([], dtype: float64)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results = TimeSeries()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can add a value to the `TimeSeries` like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "0    4\n",
       "dtype: int64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results[0] = bikeshare.olin\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `0` in brackets is an `index` that indicates that this value is associated with time step 0.\n",
    "\n",
    "Now we'll use a for loop to save the results of the simulation.  I'll start one more time with a new `State` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>olin</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wellesley</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "olin         10\n",
       "wellesley     2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bikeshare = State(olin=10, wellesley=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's a for loop that runs 10 steps and stores the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    step(0.3, 0.2)\n",
    "    results[i] = bikeshare.olin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can display the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>values</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "0    10\n",
       "1    10\n",
       "2     9\n",
       "3     9\n",
       "4    10\n",
       "5    10\n",
       "6    10\n",
       "7    11\n",
       "8    11\n",
       "9    11\n",
       "dtype: int64"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A `TimeSeries` is a specialized version of a Pandas `Series`, so we can use any of the functions provided by `Series`, including several that compute summary statistics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    10.000000\n",
       "mean     10.100000\n",
       "std       0.737865\n",
       "min       9.000000\n",
       "25%      10.000000\n",
       "50%      10.000000\n",
       "75%      10.750000\n",
       "max      11.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can read the documentation of `Series` [here](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "\n",
    "We can also plot the results like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving figure to file figs/chap02-fig01.pdf\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(results, label='Olin')\n",
    "\n",
    "decorate(title='Olin-Wellesley Bikeshare',\n",
    "         xlabel='Time step (min)', \n",
    "         ylabel='Number of bikes')\n",
    "\n",
    "savefig('figs/chap02-fig01.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`decorate`, which is defined in the `modsim` library, adds a title and labels the axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function decorate in module modsim.modsim:\n",
      "\n",
      "decorate(**options)\n",
      "    Decorate the current axes.\n",
      "    \n",
      "    Call decorate with keyword arguments like\n",
      "    \n",
      "    decorate(title='Title',\n",
      "             xlabel='x',\n",
      "             ylabel='y')\n",
      "    \n",
      "    The keyword arguments can be any of the axis properties\n",
      "    \n",
      "    https://matplotlib.org/api/axes_api.html\n",
      "    \n",
      "    In addition, you can use `legend=False` to suppress the legend.\n",
      "    \n",
      "    And you can use `loc` to indicate the location of the legend\n",
      "    (the default value is 'best')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(decorate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`savefig()` saves a figure in a file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function savefig in module modsim.modsim:\n",
      "\n",
      "savefig(filename, **options)\n",
      "    Save the current figure.\n",
      "    \n",
      "    Keyword arguments are passed along to plt.savefig\n",
      "    \n",
      "    https://matplotlib.org/api/_as_gen/matplotlib.pyplot.savefig.html\n",
      "    \n",
      "    filename: string\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(savefig)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The suffix of the filename indicates the format you want.  This example saves the current figure in a PDF file named `chap01-fig01.pdf`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise:** Wrap the code from this section in a function named `run_simulation` that takes three parameters, named `p1`, `p2`, and `num_steps`.\n",
    "\n",
    "It should:\n",
    "\n",
    "1. Create a `TimeSeries` object to hold the results.\n",
    "2. Use a for loop to run `step` the number of times specified by `num_steps`, passing along the specified values of `p1` and `p2`.\n",
    "3. After each step, it should save the number of bikes at Olin in the `TimeSeries`.\n",
    "4. After the for loop, it should plot the results and\n",
    "5. Decorate the axes.\n",
    "\n",
    "To test your function:\n",
    "\n",
    "1. Create a `State` object with the initial state of the system.\n",
    "2. Call `run_simulation` with appropriate parameters.\n",
    "3. Save the resulting figure.\n",
    "\n",
    "Optional:\n",
    "\n",
    "1. Extend your solution so it creates two `TimeSeries` objects, keeps track of the number of bikes at Olin *and* at Wellesley, and plots both series at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Solution\n",
    "\n",
    "def run_simulation(p1, p2, num_steps):\n",
    "    olin = TimeSeries()\n",
    "    wellesley = TimeSeries()\n",
    "    \n",
    "    for i in range(num_steps):\n",
    "        step(p1, p2)\n",
    "        olin[i] = bikeshare.olin\n",
    "        wellesley[i] = bikeshare.wellesley\n",
    "        \n",
    "    plot(olin, label='Olin')\n",
    "    plot(wellesley, label='Wellesley')\n",
    "    decorate(title='Olin-Wellesley Bikeshare',\n",
    "             xlabel='Time step (min)', \n",
    "             ylabel='Number of bikes')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Solution\n",
    "\n",
    "bikeshare = State(olin=10, wellesley=2)\n",
    "run_simulation(0.3, 0.2, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opening the hood\n",
    "\n",
    "The functions in `modsim.py` are built on top of several widely-used Python libraries, especially NumPy, SciPy, and Pandas.  These libraries are powerful but can be hard to use.  The intent of `modsim.py` is to give you the power of these libraries while making it easy to get started.\n",
    "\n",
    "In the future, you might want to use these libraries directly, rather than using `modsim.py`.  So we will pause occasionally to open the hood and let you see how `modsim.py` works.\n",
    "\n",
    "You don't need to know anything in these sections, so if you are already feeling overwhelmed, you might want to skip them.  But if you are curious, read on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pandas\n",
    "\n",
    "This chapter introduces two objects, `State` and `TimeSeries`.  Both are based on the `Series` object defined by Pandas, which is a library primarily used for data science.\n",
    "\n",
    "You can read the documentation of the `Series` object [here](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html)\n",
    "\n",
    "The primary differences between `TimeSeries` and `Series` are:\n",
    "\n",
    "1. I made it easier to create a new, empty `Series` while avoiding a [confusing inconsistency](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html).\n",
    "\n",
    "2. I provide a function so the `Series` looks good when displayed in Jupyter.\n",
    "\n",
    "3. I provide a function called `set` that we'll use later.\n",
    "\n",
    "`State` has all of those capabilities; in addition, it provides an easier way to initialize state variables, and it provides functions called `T` and `dt`, which will help us avoid a confusing error later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pyplot\n",
    "\n",
    "The `plot` function in `modsim.py` is based on the `plot` function in Pyplot, which is part of Matplotlib.  You can read the documentation of `plot` [here](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.plot.html).\n",
    "\n",
    "`decorate` provides a convenient way to call the `pyplot` functions `title`, `xlabel`, and `ylabel`, and `legend`.  It also avoids an annoying warning message if you try to make a legend when you don't have any labelled lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function decorate in module modsim.modsim:\n",
      "\n",
      "decorate(**options)\n",
      "    Decorate the current axes.\n",
      "    \n",
      "    Call decorate with keyword arguments like\n",
      "    \n",
      "    decorate(title='Title',\n",
      "             xlabel='x',\n",
      "             ylabel='y')\n",
      "    \n",
      "    The keyword arguments can be any of the axis properties\n",
      "    \n",
      "    https://matplotlib.org/api/axes_api.html\n",
      "    \n",
      "    In addition, you can use `legend=False` to suppress the legend.\n",
      "    \n",
      "    And you can use `loc` to indicate the location of the legend\n",
      "    (the default value is 'best')\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(decorate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy\n",
    "\n",
    "The `flip` function in `modsim.py` uses NumPy's `random` function to generate a random number between 0 and 1.\n",
    "\n",
    "You can get the source code for `flip` by running the following cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "def flip(p=0.5):\n",
      "    \"\"\"Flips a coin with the given probability.\n",
      "\n",
      "    p: float 0-1\n",
      "\n",
      "    returns: boolean (True or False)\n",
      "    \"\"\"\n",
      "    return np.random.random() < p\n",
      "\n"
     ]
    }
   ],
   "source": [
    "source_code(flip)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
